package com.dt.platform.vehicle.service.impl;


import javax.annotation.Resource;

import com.dt.platform.constants.enums.eam.AssetOperateEnum;
import com.dt.platform.constants.enums.vehicle.VehicleApplyReturnEnum;
import com.dt.platform.constants.enums.vehicle.VehicleHandleStatusEnum;
import com.dt.platform.constants.enums.vehicle.VehicleOperationEnum;
import com.dt.platform.constants.enums.vehicle.VehicleStatusEnum;
import com.dt.platform.domain.vehicle.Info;
import com.dt.platform.domain.vehicle.meta.ApplyMeta;
import com.dt.platform.domain.vehicle.meta.MaintenanceMeta;
import com.dt.platform.proxy.common.CodeModuleServiceProxy;
import com.dt.platform.vehicle.service.IInfoService;
import com.github.foxnic.commons.lang.StringUtil;
import org.github.foxnic.web.session.SessionUser;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;


import com.dt.platform.domain.vehicle.Apply;
import com.dt.platform.domain.vehicle.ApplyVO;
import java.util.List;
import com.github.foxnic.api.transter.Result;
import com.github.foxnic.dao.data.PagedList;
import com.github.foxnic.dao.entity.SuperService;
import com.github.foxnic.dao.spec.DAO;
import java.lang.reflect.Field;
import com.github.foxnic.commons.busi.id.IDGenerator;
import com.github.foxnic.sql.expr.ConditionExpr;
import com.github.foxnic.api.error.ErrorDesc;
import com.github.foxnic.dao.excel.ExcelWriter;
import com.github.foxnic.dao.excel.ValidateResult;
import com.github.foxnic.dao.excel.ExcelStructure;
import java.io.InputStream;
import com.github.foxnic.sql.meta.DBField;
import com.github.foxnic.dao.data.SaveMode;
import com.github.foxnic.dao.meta.DBColumnMeta;
import com.github.foxnic.sql.expr.Select;
import java.util.ArrayList;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import com.dt.platform.vehicle.service.IApplyService;
import org.github.foxnic.web.framework.dao.DBConfigs;
import java.util.Date;

/**
 * <p>
 * 车辆申请 服务实现
 * </p>
 * @author 金杰 , maillank@qq.com
 * @since 2022-04-02 19:49:05
*/


@Service("VehicleApplyService")
public class ApplyServiceImpl extends SuperService<Apply> implements IApplyService {


	@Autowired
	private IInfoService infoService;
	/**
	 * 注入DAO对象
	 * */
	@Resource(name=DBConfigs.PRIMARY_DAO)
	private DAO dao=null;

	/**
	 * 获得 DAO 对象
	 * */
	public DAO dao() { return dao; }

	@Autowired
	private ASelectItemServiceImpl aSelectItemServiceImpl;


	@Override
	public Object generateId(Field field) {
		return IDGenerator.getSnowflakeIdString();
	}



	@Override
	public Result actionReturn(String id,String notes) {
		Apply data=this.getById(id);
		if(VehicleApplyReturnEnum.Y.code().equals(data.getIfReturn())){
			return  ErrorDesc.failureMessage("不需重复归还");
		}
		this.dao().fill(data)
				.with(ApplyMeta.VEHICLE_INFO_LIST)
				.execute();
		List<Info> list=data.getVehicleInfoList();
		if(list==null||list.size()==0){
			return ErrorDesc.failureMessage("当前清单为空");
		}
		for(int i=0;i<list.size();i++){
			Info info=list.get(i);
			info.setVehicleStatus(VehicleStatusEnum.IDLE.code());
			infoService.save(info,SaveMode.NOT_NULL_FIELDS);
		}
		data.setIfReturn(VehicleApplyReturnEnum.Y.code());
		data.setReturnNotes(notes);
		data.setActReturnDate(new Date());
		return super.update(data,SaveMode.NOT_NULL_FIELDS,false);

	}


	@Override
	public Result confirm(String id) {
		Apply data=this.getById(id);
		this.dao().fill(data)
				.with(ApplyMeta.VEHICLE_INFO_LIST)
				.execute();
		List<Info> list=data.getVehicleInfoList();
		if(list==null||list.size()==0){
			return ErrorDesc.failureMessage("当前清单为空");
		}
		for(int i=0;i<list.size();i++){
			Info info=list.get(i);
			info.setVehicleStatus(VehicleStatusEnum.INUSE.code());
			infoService.save(info,SaveMode.NOT_NULL_FIELDS);
		}
		data.setStatus(VehicleHandleStatusEnum.COMPLETE.code());
		return super.update(data,SaveMode.NOT_NULL_FIELDS,false);

	}

	@Override
	public Result cancel(String id) {
		Apply data=this.getById(id);
		this.dao().fill(data)
				.with(ApplyMeta.VEHICLE_INFO_LIST)
				.execute();
		List<Info> list=data.getVehicleInfoList();
		if(list==null||list.size()==0){
			return ErrorDesc.failureMessage("当前清单为空");
		}
		if(VehicleHandleStatusEnum.INCOMPLETE.code().equals(data.getStatus())){
			for(int i=0;i<list.size();i++){
				Info info=list.get(i);
				info.setVehicleStatus(VehicleStatusEnum.IDLE.code());
				infoService.save(info,SaveMode.NOT_NULL_FIELDS);
			}
			data.setStatus(VehicleHandleStatusEnum.CANCEL.code());
			return super.update(data,SaveMode.NOT_NULL_FIELDS,false);
		}else{
			return ErrorDesc.failureMessage("当前状态不能进行该操作");
		}
	}

	/**
	 * 添加，根据 throwsException 参数抛出异常或返回 Result 对象
	 *
	 * @param apply  数据对象
	 * @param throwsException 是否抛出异常，如果不抛出异常，则返回一个失败的 Result 对象
	 * @return 结果 , 如果失败返回 false，成功返回 true
	 */
	@Override
	@Transactional
	public Result insert(Apply apply,boolean throwsException) {


		//校验数据资产
		if(apply.getVehicleInfoIds()==null||apply.getVehicleInfoIds().size()==0){
			return ErrorDesc.failure().message("请选择车辆");
		}else{
			//修改为预定
			for(int i=0;i<apply.getVehicleInfoIds().size();i++){
				Info info=new Info();
				info.setVehicleStatus(VehicleStatusEnum.ORDER.code());
				info.setId(apply.getVehicleInfoIds().get(i));
				infoService.update(info,SaveMode.NOT_NULL_FIELDS);
			}
		}

		//制单人
		if(StringUtil.isBlank(apply.getOriginatorId())){
			apply.setOriginatorId(SessionUser.getCurrent().getUser().getActivatedEmployeeId());
		}

		//办理状态
		if(StringUtil.isBlank(apply.getStatus())){
			apply.setStatus(VehicleHandleStatusEnum.INCOMPLETE.code());
		}

		//生成编码规则
		if(StringUtil.isBlank(apply.getBusinessCode())){
			Result codeResult= CodeModuleServiceProxy.api().generateCode(VehicleOperationEnum.VEHICLE_APPLY.code());
			if(!codeResult.isSuccess()){
				return codeResult;
			}else{
				apply.setBusinessCode(codeResult.getData().toString());
			}
		}
		Result r=super.insert(apply,throwsException);
		//保存关系
		if(r.success()) {
			aSelectItemServiceImpl.saveRelation(apply.getId(), apply.getVehicleInfoIds());
		}
		return r;
	}


	/**
	 * 添加，如果语句错误，则抛出异常
	 * @param apply 数据对象
	 * @return 插入是否成功
	 * */
	@Override
	@Transactional
	public Result insert(Apply apply) {
		return this.insert(apply,true);
	}

	/**
	 * 批量插入实体，事务内
	 * @param applyList 实体数据清单
	 * @return 插入是否成功
	 * */
	@Override
	public Result insertList(List<Apply> applyList) {
		return super.insertList(applyList);
	}


	/**
	 * 按主键删除 车辆申请
	 *
	 * @param id 主键
	 * @return 删除是否成功
	 */
	public Result deleteByIdPhysical(String id) {


		Apply apply = new Apply();
		if(id==null) return ErrorDesc.failure().message("id 不允许为 null 。");
		apply.setId(id);
		try {
			boolean suc = dao.deleteEntity(apply);
			return suc?ErrorDesc.success():ErrorDesc.failure();
		}
		catch(Exception e) {
			Result r= ErrorDesc.failure();
			r.extra().setException(e);
			return r;
		}
	}

	/**
	 * 按主键删除 车辆申请
	 *
	 * @param id 主键
	 * @return 删除是否成功
	 */
	public Result deleteByIdLogical(String id) {
		if(id==null) return ErrorDesc.failure().message("id 不允许为 null 。");
		Apply data=this.getById(id);
		this.dao().fill(data)
				.with(ApplyMeta.VEHICLE_INFO_LIST)
				.execute();
		List<Info> list=data.getVehicleInfoList();
		if(VehicleHandleStatusEnum.INCOMPLETE.code().equals(data.getStatus())){
			if(list!=null&&list.size()>0){
				for(int i=0;i<list.size();i++){
					Info info=list.get(i);
					info.setVehicleStatus(VehicleStatusEnum.IDLE.code());
					infoService.save(info,SaveMode.NOT_NULL_FIELDS);
				}
			}
		}else{
			return ErrorDesc.failureMessage("当前状态不能进行该操作");
		}

		Apply apply=new Apply();
		apply.setId(id);
		apply.setDeleted(dao.getDBTreaty().getTrueValue());
		apply.setDeleteBy((String)dao.getDBTreaty().getLoginUserId());
		apply.setDeleteTime(new Date());
		try {
			boolean suc = dao.updateEntity(apply,SaveMode.NOT_NULL_FIELDS);
			return suc?ErrorDesc.success():ErrorDesc.failure();
		}
		catch(Exception e) {
			Result r= ErrorDesc.failure();
			r.extra().setException(e);
			return r;
		}
	}

	/**
	 * 更新，如果执行错误，则抛出异常
	 * @param apply 数据对象
	 * @param mode 保存模式
	 * @return 保存是否成功
	 * */
	@Override
	@Transactional
	public Result update(Apply apply , SaveMode mode) {
		return this.update(apply,mode,true);
	}

	/**
	 * 更新，根据 throwsException 参数抛出异常或返回 Result 对象
	 * @param apply 数据对象
	 * @param mode 保存模式
	 * @param throwsException 是否抛出异常，如果不抛出异常，则返回一个失败的 Result 对象
	 * @return 保存是否成功
	 * */
	@Override
	@Transactional
	public Result update(Apply apply , SaveMode mode,boolean throwsException) {
		//校验数据资产

		if(apply.getVehicleInfoIds()==null||apply.getVehicleInfoIds().size()==0){
			return ErrorDesc.failure().message("请选择车辆");
		}else{
			this.dao().fill(apply)
				.with(ApplyMeta.VEHICLE_INFO_LIST)
				.execute();
			//修改为闲置
			for(int i=0;i<apply.getVehicleInfoList().size();i++){
				Info info=new Info();
				info.setVehicleStatus(VehicleStatusEnum.IDLE.code());
				info.setId(apply.getVehicleInfoList().get(i).getId());
				infoService.update(info,SaveMode.NOT_NULL_FIELDS);
			}

			//修改为预定

			for(int i=0;i<apply.getVehicleInfoIds().size();i++){
				Info info=new Info();
				info.setVehicleStatus(VehicleStatusEnum.ORDER.code());
				info.setId(apply.getVehicleInfoIds().get(i));
				infoService.update(info,SaveMode.NOT_NULL_FIELDS);
			}
		}

		Result r=super.update(apply , mode , throwsException);
		//保存关系
		if(r.success()) {
			aSelectItemServiceImpl.saveRelation(apply.getId(), apply.getVehicleInfoIds());
		}
		return r;
	}

	/**
	 * 更新实体集，事务内
	 * @param applyList 数据对象列表
	 * @param mode 保存模式
	 * @return 保存是否成功
	 * */
	@Override
	public Result updateList(List<Apply> applyList , SaveMode mode) {
		return super.updateList(applyList , mode);
	}


	/**
	 * 按主键更新字段 车辆申请
	 *
	 * @param id 主键
	 * @return 是否更新成功
	 */
	public boolean update(DBField field,Object value , String id) {
		if(id==null) throw new IllegalArgumentException("id 不允许为 null ");
		if(!field.table().name().equals(this.table())) throw new IllegalArgumentException("更新的数据表["+field.table().name()+"]与服务对应的数据表["+this.table()+"]不一致");
		int suc=dao.update(field.table().name()).set(field.name(), value).where().and("id = ? ",id).top().execute();
		return suc>0;
	}


	/**
	 * 按主键获取 车辆申请
	 *
	 * @param id 主键
	 * @return Apply 数据对象
	 */
	public Apply getById(String id) {
		Apply sample = new Apply();
		if(id==null) throw new IllegalArgumentException("id 不允许为 null ");
		sample.setId(id);
		return dao.queryEntity(sample);
	}

	@Override
	public List<Apply> getByIds(List<String> ids) {
		return super.queryListByUKeys("id",ids);
	}



	/**
	 * 查询实体集合，默认情况下，字符串使用模糊匹配，非字符串使用精确匹配
	 *
	 * @param sample  查询条件
	 * @return 查询结果
	 * */
	@Override
	public List<Apply> queryList(Apply sample) {
		return super.queryList(sample);
	}


	/**
	 * 分页查询实体集，字符串使用模糊匹配，非字符串使用精确匹配
	 *
	 * @param sample  查询条件
	 * @param pageSize 分页条数
	 * @param pageIndex 页码
	 * @return 查询结果
	 * */
	@Override
	public PagedList<Apply> queryPagedList(Apply sample, int pageSize, int pageIndex) {
		return super.queryPagedList(sample, pageSize, pageIndex);
	}

	/**
	 * 分页查询实体集，字符串使用模糊匹配，非字符串使用精确匹配
	 *
	 * @param sample  查询条件
	 * @param condition 其它条件
	 * @param pageSize 分页条数
	 * @param pageIndex 页码
	 * @return 查询结果
	 * */
	@Override
	public PagedList<Apply> queryPagedList(Apply sample, ConditionExpr condition, int pageSize, int pageIndex) {
		return super.queryPagedList(sample, condition, pageSize, pageIndex);
	}

	/**
	 * 检查 实体 是否已经存在 , 判断 主键值不同，但指定字段的值相同的记录是否存在
	 *
	 * @param apply 数据对象
	 * @return 判断结果
	 */
	public Boolean checkExists(Apply apply) {
		//TDOD 此处添加判断段的代码
		//boolean exists=super.checkExists(apply, SYS_ROLE.NAME);
		//return exists;
		return false;
	}

	@Override
	public ExcelWriter exportExcel(Apply sample) {
		return super.exportExcel(sample);
	}

	@Override
	public ExcelWriter exportExcelTemplate() {
		return super.exportExcelTemplate();
	}

	@Override
	public List<ValidateResult> importExcel(InputStream input,int sheetIndex,boolean batch) {
		return super.importExcel(input,sheetIndex,batch);
	}

	@Override
	public ExcelStructure buildExcelStructure(boolean isForExport) {
		return super.buildExcelStructure(isForExport);
	}


}
